1. Operadores aritméticos: se utilizan para realizar operaciones matemáticas básicas, como la suma, la resta, la multiplicación y la división.

• Suma (+): se utiliza para sumar dos valores.
• Resta (-): se utiliza para restar un valor de otro.
• Multiplicación (*): se utiliza para multiplicar dos valores.
• División (/): se utiliza para dividir un valor entre otro.
• Módulo (%): se utiliza para obtener el resto de la división entre dos valores.

let x = 10;
let y = 3;

console.log(x + y); // Devuelve 13
console.log(x - y); // Devuelve 7
console.log(x * y); // Devuelve 30
console.log(x / y); // Devuelve 3.3333333333333335
console.log(x % y); // Devuelve 1
 

2. Operadores de asignación: se utilizan para asignar valores a variables.

• Asignación (=): se utiliza para asignar un valor a una variable.
• Asignación de suma (+=): se utiliza para sumar un valor a una variable existente.
• Asignación de resta (-=): se utiliza para restar un valor a una variable existente.
• Asignación de multiplicación (*=): se utiliza para multiplicar un valor por una variable existente.
• Asignación de división (/=): se utiliza para dividir un valor por una variable existente.

let x = 5;

x += 3; // Equivale a x = x + 3
console.log(x); // Devuelve 8

x -= 2; // Equivale a x = x - 2
console.log(x); // Devuelve 6

x *= 4; // Equivale a x = x * 4
console.log(x); // Devuelve 24

x /= 3; // Equivale a x = x / 3
console.log(x); // Devuelve 8

x %= 5; // Equivale a x = x % 5
console.log(x); // Devuelve 3
 

3. Operadores de comparación: se utilizan para comparar valores y devolver un resultado booleano (verdadero o falso).

• Igualdad (==): se utiliza para comparar si dos valores son iguales.
• Desigualdad (!=): se utiliza para comparar si dos valores son diferentes.
• Igualdad estricta (===): se utiliza para comparar si dos valores son iguales y del mismo tipo.
• Desigualdad estricta (!==): se utiliza para comparar si dos valores son diferentes y del mismo tipo.
• Mayor que (>), mayor o igual que (>=), menor que (<) y menor o igual que (<=): se utilizan para comparar valores numéricos.

let x = 10;
let y = 5;

console.log(x == y); // Devuelve false
console.log(x != y); // Devuelve true
console.log(x === "10"); // Devuelve false
console.log(x !== "10"); // Devuelve true
console.log(x > y); // Devuelve true
console.log(x >= y); // Devuelve true
console.log(x < y); // Devuelve false
console.log(x <= y); // Devuelve false
 

4. Operadores lógicos: se utilizan para realizar operaciones booleanas.

• Y lógico (&&): devuelve verdadero si ambos operandos son verdaderos.
• O lógico (||): devuelve verdadero si al menos uno de los operandos es verdadero.
• Negación lógica (!): invierte el valor booleano de un operando.

let x = 5;
let y = 10;

console.log(x < y && y < 20); // Devuelve true
console.log(x > y || y < 20); // Devuelve true
console.log(!(x < y)); // Devuelve false
 

5. Operadores de incremento y decremento: se utilizan para aumentar o disminuir el valor de una variable en uno.

• Incremento (++): se utiliza para aumentar el valor de una variable en uno.
• Decremento (--): se utiliza para disminuir el valor de una variable en uno.

Los operadores de bit a bit son utilizados para realizar operaciones a nivel de bits en los números. A continuación, te mostraré los operadores de bit a bit en JavaScript:

1. Operador AND a nivel de bits (&): Devuelve un 1 en cada posición en la que los bits de ambos operandos son 1.

let x = 5; // 101 en binario let y = 3; // 011 en binario console.log(x & y); // Devuelve 1 (001 en binario) 

2. Operador OR a nivel de bits (|): Devuelve un 1 en cada posición en la que al menos uno de los bits de los operandos es 1.

let x = 5; // 101 en binario let y = 3; // 011 en binario console.log(x | y); // Devuelve 7 (111 en binario) 

3. Operador XOR a nivel de bits (^): Devuelve un 1 en cada posición en la que los bits de los operandos son diferentes.

let x = 5; // 101 en binario let y = 3; // 011 en binario console.log(x ^ y); // Devuelve 6 (110 en binario) 

4. Operador NOT a nivel de bits (~): Invierte todos los bits de un número.

let x = 5; // 101 en binario console.log(~x); // Devuelve -6 (complemento a 2 de 010 en binario) 

5. Operador desplazamiento a la izquierda (<<): Desplaza los bits del primer operando a la izquierda el número de posiciones especificado por el segundo operando.

let x = 5; // 101 en binario console.log(x << 1); // Devuelve 10 (1010 en binario) 

6. Operador desplazamiento a la derecha (>>): Desplaza los bits del primer operando a la derecha el número de posiciones especificado por el segundo operando.

let x = 5; // 101 en binario console.log(x >> 1); // Devuelve 2 (10 en binario) 

7. Operador desplazamiento a la derecha sin signo (>>>): Desplaza los bits del primer operando a la derecha el número de posiciones especificado por el segundo operando. Los bits vacantes son llenados con ceros en lugar del bit de signo.

 let x = -5; // 11111111111111111111111111111011 en binario (complemento a 2) console.log(x >>> 1); // Devuelve 2147483645 (01111111111111111111111111111101 en binario)